package com.sign2024.sign2024project.signBase.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sign2024.sign2024core.common.constants.CommonConstants;
import com.sign2024.sign2024core.common.exeception.CommonException;
import com.sign2024.sign2024core.common.utils.StringUtils;
import com.sign2024.sign2024project.capitalconstruction.vo.JjProgectVo;
import com.sign2024.sign2024project.signBase.entry.BaseDisclose;
import com.sign2024.sign2024project.signBase.entry.SignBase;
import com.sign2024.sign2024project.signBase.mapper.BaseDiscloseMapper;
import com.sign2024.sign2024project.signBase.mapper.SignBaseMapper;
import com.sign2024.sign2024project.signBase.param.BaseParam;
import com.sign2024.sign2024project.signBase.service.SignBaseService;
import com.sign2024.sign2024project.signBase.vo.GCBaseVo;
import com.sign2024.sign2024project.signBase.vo.WzBaseVo;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author yujie
 * @data 2024/11/25 15:43
 */
@Service
public class SignBaseServiceImpl implements SignBaseService {

    @Resource
    private SignBaseMapper signBaseMapper;

    @Resource
    private BaseDiscloseMapper baseDiscloseMapper;

    @Override
    public Page<SignBase> pageSignBase(BaseParam param) {
        Integer offset = (param.getPageNum() - 1) * param.getPageSize();
        param.setOffset(offset);

        // 分页查询
        Page<SignBase> page = new Page<>(param.getPageNum(), param.getPageSize());
        List<SignBase> list = signBaseMapper.selectSignBaseByPage(param);

        // 页码
        page.setCurrent(param.getPageNum());
        page.setSize(param.getPageSize());

        // 总记录数
        Long aLong = signBaseMapper.pageSignBaseCount(param);
        page.setTotal(aLong);
        page.setRecords(list);
        return page;
    }

    @Override
    public void insertSignBase(SignBase signBase) {
        if (signBase.getBaseRoom() == null) {
            throw new CommonException(CommonConstants.ERROR, "评标室不可为空");
        }

        if (signBase.getPersonNum() == null) {
            throw new CommonException(CommonConstants.ERROR, "评标室人数不可为空");
        }

        if (signBase.getBaseId() == null) {
            throw new CommonException(CommonConstants.ERROR, "评标基地信息不可为空");
        }

        // 判断 该 评标室是否 已存在
        SignBase base = signBaseMapper.selectBaseByRoom(signBase.getBaseRoom(), signBase.getBaseFlag(), signBase.getBaseId());
        if (base != null) {
            throw new CommonException(CommonConstants.ERROR, "该评标室已存在，请核对信息");
        }

        signBaseMapper.insertSignBase(signBase);

    }

    @Override
    public void updateSignBase(SignBase signBase) {
        if (signBase.getBaseRoom() == null) {
            throw new CommonException(CommonConstants.ERROR, "评标室不可为空");
        }

        if (signBase.getPersonNum() == null) {
            throw new CommonException(CommonConstants.ERROR, "评标室人数不可为空");
        }

//        if (signBase.getBaseId() == null) {
//            throw new CommonException(CommonConstants.ERROR, "评标基地信息不可为空");
//        }

        // 判断 该 评标室是否 已存在
        SignBase base = signBaseMapper.selectBaseByRoom(signBase.getBaseRoom(), signBase.getBaseFlag(), signBase.getBaseId());
        if (base != null) {
            // 如果评标室已存在，并且 ID 匹配，则允许更新
            if (base.getId().equals(signBase.getId())) {
                signBaseMapper.updateSignBase(signBase);
            } else {
                // 如果评标室已存在，但 ID 不匹配，则抛出异常
                throw new CommonException(CommonConstants.ERROR, "该评标室已存在，请核对信息");
            }
        } else {
            // 如果评标室不存在，则允许更新
            signBaseMapper.updateSignBase(signBase);
        }
    }

    @Override
    public boolean deleteById(Integer id) {
        int total = signBaseMapper.deleteById(id);
        return total > 0;
    }

    @Override
    public List<GCBaseVo> createSignBase(List<GCBaseVo> list, String baseName) {
        if (baseName == null) {
            throw new CommonException(CommonConstants.ERROR, "请选择基地信息");
        }

        // 根据 基地名称获取 基地信息
        BaseDisclose disclose = baseDiscloseMapper.selectBaseByName(baseName);

        // 对 技术分组 以及 商务 分组数据 进行处理
        if (!list.isEmpty()) {
            if (StringUtils.isNull(list.get(0).getSkillClass())) {
                throw new CommonException(CommonConstants.ERROR, "请检查excel是否正确");
            }
            for (int i = 0; i < list.size(); i++) {
                if (StringUtils.isNotNull(list.get(i))) {
                    // 手动处理 合并单元格后的数据
                    if (StringUtils.isNull(list.get(i).getSkillClass())) {
                        // 使用列表上一个数据
                        if (i != 0) {
                            String skillClass = list.get(i - 1).getSkillClass();
                            list.get(i).setSkillClass(skillClass);
                            list.set(i, list.get(i));
                        }
                    }

                    if (StringUtils.isNull(list.get(i).getBossClass())) {
                        // 使用列表上一个数据
                        if (i != 0) {
                            String bossClass = list.get(i - 1).getBossClass();
                            list.get(i).setBossClass(bossClass);
                            list.set(i, list.get(i));
                        }
                    }

                }
            }
        }

        // 获取 评标基地 信息 商务 北   技术 南
        List<SignBase> baseList = signBaseMapper.selectBaseListByFlag("南", disclose.getId());
        // 对数据进行处理， 对其数据进行分配评标室
        // 根据 技术 组 的分组 将数据 封装到 map 中
        Map<String, List<GCBaseVo>> skillClassMap = list.stream()
                .collect(Collectors.groupingBy(GCBaseVo::getSkillClass));

        // 将 技术组 组名以及 总认识 取出
        LinkedHashMap<String, Integer> skillPersonMap = new LinkedHashMap<>();
        for (int i = 0; i < skillClassMap.size(); i++) {
            String className = "技术" + convertToChinese(i + 1) + "组";
            List<GCBaseVo> voList = skillClassMap.get(className);
            if (voList.isEmpty()) {
                continue;
            }
            Integer totalNum = voList.get(0).getSkillTotalNum();
            skillPersonMap.put(className, totalNum);
        }

        // 对数据进行 对比
        LinkedHashMap<String, List<String>> skillTempMap = new LinkedHashMap<>();
        List<String> currentGroupList = new ArrayList<>();
        int currentSum = 0;

        // 遍历 baseList
        for (SignBase base : baseList) {
            Iterator<Map.Entry<String, Integer>> iterator = skillPersonMap.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, Integer> entry = iterator.next();
                String groupName = entry.getKey();
                int groupPersonCount = entry.getValue();
                // 检查当前累加的总人数是否小于等于 roomNum
                if (currentSum + groupPersonCount <= base.getPersonNum()) {
                    currentSum += groupPersonCount;
                    currentGroupList.add(groupName);
                    // 从 skillPersonMap 中移除已经分配的技术组
                    iterator.remove();
                }
            }

            // 如果当前组已经分配完成
            if (currentSum > 0) {
                skillTempMap.put(base.getBaseRoom(), new ArrayList<>(currentGroupList));
                currentSum = 0;
                currentGroupList.clear();
            }
        }

        // 处理剩余的技术组
        if (!skillPersonMap.isEmpty()) {
            throw new CommonException(CommonConstants.ERROR, "无法分配所有技术组，剩余技术组人数超过可用评标室容量");
        }

        // 对数据 进行处理
        for (Map.Entry<String, List<String>> entry : skillTempMap.entrySet()) {
//            System.out.println("评标室: " + entry.getKey() + " -> 技术组: " + entry.getValue());
            String key = entry.getKey();
            List<String> stringList = entry.getValue();
            for (String str : stringList) {
                for (GCBaseVo vo : list) {
                    if (!vo.getSkillClass().equals(str)) {
                        continue;
                    }

                    if (vo.getSkillClass().equals(str)) {
                        vo.setSkillBaseRoom(baseName + key);
                    }
                }
            }
        }


        // 获取 评标基地 信息 商务 北   技术 南
        List<SignBase> bossBaseList = signBaseMapper.selectBaseListByFlag("北", disclose.getId());
        // 对数据进行处理， 对其数据进行分配评标室
        // 根据 技术 组 的分组 将数据 封装到 map 中
        Map<String, List<GCBaseVo>> bossClassMap = list.stream()
                .collect(Collectors.groupingBy(GCBaseVo::getBossClass));

        // 将 技术组 组名以及 总认识 取出
        LinkedHashMap<String, Integer> bossPersonMap = new LinkedHashMap<>();
        for (int i = 0; i < bossClassMap.size(); i++) {
            String className = "商务" + convertToChinese(i + 1) + "组";
            List<GCBaseVo> voList = bossClassMap.get(className);
            if (voList.isEmpty()) {
                continue;
            }
            Integer totalNum = voList.get(0).getBossTotalNum();
            bossPersonMap.put(className, totalNum);
        }

        // 对数据进行 对比
        LinkedHashMap<String, List<String>> bossTempMap = new LinkedHashMap<>();
        List<String> bossGroupList = new ArrayList<>();
        int bossSum = 0;

        for (SignBase base : bossBaseList) {
            Iterator<Map.Entry<String, Integer>> iterator = bossPersonMap.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, Integer> entry = iterator.next();
                String groupName = entry.getKey();
                int groupPersonCount = entry.getValue();
                // 检查当前累加的总人数是否小于等于 roomNum
                if (bossSum + groupPersonCount <= base.getPersonNum()) {
                    bossSum += groupPersonCount;
                    bossGroupList.add(groupName);
                    iterator.remove();
                }
            }

            // 如果当前组已经分配完成
            if (bossSum > 0) {
                bossTempMap.put(base.getBaseRoom(), new ArrayList<>(bossGroupList));
                bossSum = 0;
                bossGroupList.clear();
            }
        }

        // 处理剩余的商务组
        if (!bossPersonMap.isEmpty()) {
            throw new CommonException(CommonConstants.ERROR, "无法分配所有商务组，剩余商务组人数超过可用评标室容量");
        }

        // 对数据 进行处理
        for (Map.Entry<String, List<String>> entry : bossTempMap.entrySet()) {
            String key = entry.getKey();
            List<String> stringList = entry.getValue();
            for (String str : stringList) {
                for (GCBaseVo vo : list) {
                    if (!vo.getBossClass().equals(str)) {
                        continue;
                    }

                    if (vo.getBossClass().equals(str)) {
                        vo.setBossBaseRoom(baseName + key);
                    }
                }
            }
        }


        return list;
    }

    @Override
    public List<JjProgectVo> createJjSignBase(List<JjProgectVo> list, String baseName) {
        if (baseName == null) {
            throw new CommonException(CommonConstants.ERROR, "请选择基地信息");
        }

        // 根据 基地名称获取 基地信息
        BaseDisclose disclose = baseDiscloseMapper.selectBaseByName(baseName);

        // 对 数据 进行处理
        // 对 技术分组 以及 商务 分组数据 进行处理
        if (!list.isEmpty()) {
            if (StringUtils.isNull(list.get(0).getSkillClassStr())) {
                throw new CommonException(CommonConstants.ERROR, "请检查excel是否正确");
            }
            for (int i = 0; i < list.size(); i++) {
                if (StringUtils.isNotNull(list.get(i))) {
                    // 手动处理 合并单元格后的数据
                    if (StringUtils.isNull(list.get(i).getSkillClassStr())) {
                        // 使用列表上一个数据
                        if (i != 0) {
                            String skillClass = list.get(i - 1).getSkillClassStr();
                            list.get(i).setSkillClassStr(skillClass);
                            list.set(i, list.get(i));
                        }
                    }

                    if (StringUtils.isNull(list.get(i).getBossClassStr())) {
                        // 使用列表上一个数据
                        if (i != 0) {
                            String bossClass = list.get(i - 1).getBossClassStr();
                            list.get(i).setBossClassStr(bossClass);
                            list.set(i, list.get(i));
                        }
                    }
                }
            }
        }

        // 处理分组数据
        for (JjProgectVo vo : list) {
            vo.setSkillClass(extractGroupName(vo.getSkillClassStr()));
            vo.setBossClass(extractGroupName(vo.getBossClassStr()));
        }

        // 获取 评标基地 信息 商务 北   技术 南
        List<SignBase> baseList = signBaseMapper.selectBaseListByFlag("南", disclose.getId());
        // 对数据进行处理， 对其数据进行分配评标室
        // 根据 技术 组 的分组 将数据 封装到 map 中
        Map<String, List<JjProgectVo>> skillClassMap = list.stream()
                .collect(Collectors.groupingBy(JjProgectVo::getSkillClass));
        // 将 技术组 组名以及 总认识 取出
        LinkedHashMap<String, Integer> skillPersonMap = new LinkedHashMap<>();
        for (int i = 0; i < skillClassMap.size(); i++) {
            String className = "技术" + convertToChinese(i + 1) + "组";
            List<JjProgectVo> voList = skillClassMap.get(className);
            if (voList.isEmpty()) {
                continue;
            }
            // 处理人数
            String bossTotalStr = voList.get(0).getSkillTotalStr();
            Integer number = extractNumber(bossTotalStr);
            skillPersonMap.put(className, number);
        }

        // 对数据进行 对比
        LinkedHashMap<String, List<String>> skillTempMap = new LinkedHashMap<>();
        List<String> currentGroupList = new ArrayList<>();
        int currentSum = 0;

        // 遍历 baseList
        for (SignBase base : baseList) {
            Iterator<Map.Entry<String, Integer>> iterator = skillPersonMap.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, Integer> entry = iterator.next();
                String groupName = entry.getKey();
                int groupPersonCount = entry.getValue();
                // 检查当前累加的总人数是否小于等于 roomNum
                if (currentSum + groupPersonCount <= base.getPersonNum()) {
                    currentSum += groupPersonCount;
                    currentGroupList.add(groupName);
                    // 从 skillPersonMap 中移除已经分配的技术组
                    iterator.remove();
                }
            }

            // 如果当前组已经分配完成
            if (currentSum > 0) {
                skillTempMap.put(base.getBaseRoom(), new ArrayList<>(currentGroupList));
                currentSum = 0;
                currentGroupList.clear();
            }
        }

        // 处理剩余的技术组
        if (!skillPersonMap.isEmpty()) {
            throw new CommonException(CommonConstants.ERROR, "无法分配所有技术组，剩余技术组人数超过可用评标室容量");
        }

        // 对数据 进行处理
        for (Map.Entry<String, List<String>> entry : skillTempMap.entrySet()) {
//            System.out.println("评标室: " + entry.getKey() + " -> 技术组: " + entry.getValue());
            String key = entry.getKey();
            List<String> stringList = entry.getValue();
            for (String str : stringList) {
                for (JjProgectVo vo : list) {
                    if (!vo.getSkillClass().equals(str)) {
                        continue;
                    }

                    if (vo.getSkillClass().equals(str)) {
                        vo.setSkillRoom(baseName + key);
                    }
                }
            }
        }

        // 获取 评标基地 信息 商务 北   技术 南
        List<SignBase> bossBaseList = signBaseMapper.selectBaseListByFlag("北", disclose.getId());
        // 对数据进行处理， 对其数据进行分配评标室
        // 根据 技术 组 的分组 将数据 封装到 map 中
        Map<String, List<JjProgectVo>> bossClassMap = list.stream()
                .collect(Collectors.groupingBy(JjProgectVo::getBossClass));

        // 将 技术组 组名以及 总认识 取出
        LinkedHashMap<String, Integer> bossPersonMap = new LinkedHashMap<>();
        for (int i = 0; i < bossClassMap.size(); i++) {
            String className = "商务" + convertToChinese(i + 1) + "组";
            List<JjProgectVo> voList = bossClassMap.get(className);
            if (voList.isEmpty()) {
                continue;
            }
            // 处理人数
            String bossTotalStr = voList.get(0).getBossTotalStr();
            Integer number = extractNumber(bossTotalStr);
            bossPersonMap.put(className, number);
        }

        // 对数据进行 对比
        LinkedHashMap<String, List<String>> bossTempMap = new LinkedHashMap<>();
        List<String> bossGroupList = new ArrayList<>();
        int bossSum = 0;

        for (SignBase base : bossBaseList) {
            Iterator<Map.Entry<String, Integer>> iterator = bossPersonMap.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, Integer> entry = iterator.next();
                String groupName = entry.getKey();
                int groupPersonCount = entry.getValue();
                // 检查当前累加的总人数是否小于等于 roomNum
                if (bossSum + groupPersonCount <= base.getPersonNum()) {
                    bossSum += groupPersonCount;
                    bossGroupList.add(groupName);
                    iterator.remove();
                }
            }

            // 如果当前组已经分配完成
            if (bossSum > 0) {
                bossTempMap.put(base.getBaseRoom(), new ArrayList<>(bossGroupList));
                bossSum = 0;
                bossGroupList.clear();
            }
        }

        // 处理剩余的商务组
        if (!bossPersonMap.isEmpty()) {
            throw new CommonException(CommonConstants.ERROR, "无法分配所有商务组，剩余商务组人数超过可用评标室容量");
        }

        // 对数据 进行处理
        for (Map.Entry<String, List<String>> entry : bossTempMap.entrySet()) {
            String key = entry.getKey();
            List<String> stringList = entry.getValue();
            for (String str : stringList) {
                for (JjProgectVo vo : list) {
                    if (!vo.getBossClass().equals(str)) {
                        continue;
                    }

                    if (vo.getBossClass().equals(str)) {
                        vo.setBossRoom(baseName + key);
                    }
                }
            }
        }

        return list;
    }

    @Override
    public List<WzBaseVo> createWzSignBase(List<WzBaseVo> list, String baseName) {
        if (baseName == null) {
            throw new CommonException(CommonConstants.ERROR, "请选择基地信息");
        }

        // 根据 基地名称获取 基地信息
        BaseDisclose disclose = baseDiscloseMapper.selectBaseByName(baseName);
        // 对 技术分组 以及 商务 分组数据 进行处理
        if (!list.isEmpty()) {
            if (StringUtils.isNull(list.get(0).getSkillClass())) {
                throw new CommonException(CommonConstants.ERROR, "请检查excel是否正确");
            }
            for (int i = 0; i < list.size(); i++) {
                if (StringUtils.isNotNull(list.get(i))) {
                    // 手动处理 合并单元格后的数据
                    if (StringUtils.isNull(list.get(i).getSkillClass())) {
                        // 使用列表上一个数据
                        if (i != 0) {
                            String skillClass = list.get(i - 1).getSkillClass();
                            list.get(i).setSkillClass(skillClass);
                            list.set(i, list.get(i));
                        }
                    }

                    if (StringUtils.isNull(list.get(i).getBossClass())) {
                        // 使用列表上一个数据
                        if (i != 0) {
                            String bossClass = list.get(i - 1).getBossClass();
                            list.get(i).setBossClass(bossClass);
                            list.set(i, list.get(i));
                        }
                    }

                }
            }
        }

        // 获取 评标基地 信息 商务 北   技术 南
        List<SignBase> baseList = signBaseMapper.selectBaseListByFlag("南", disclose.getId());
        // 对数据进行处理， 对其数据进行分配评标室
        // 根据 技术 组 的分组 将数据 封装到 map 中
        Map<String, List<WzBaseVo>> skillClassMap = list.stream()
                .collect(Collectors.groupingBy(WzBaseVo::getSkillClass));
        // 将 技术组 组名以及 总认识 取出
        LinkedHashMap<String, Integer> skillPersonMap = new LinkedHashMap<>();
        for (int i = 0; i < skillClassMap.size(); i++) {
            String className = "技术" + convertToChinese(i + 1) + "组";
            List<WzBaseVo> voList = skillClassMap.get(className);
            if (voList.isEmpty()) {
                continue;
            }
            // 物资 处理 人数
            // 本地
            Integer skillLocalNum = voList.get(0).getSkillLocalNum();
            // 异地
            Integer skillOtherNum = voList.get(0).getSkillOtherNum();
            if (skillOtherNum == null) {
                skillOtherNum = 0;
            }
            skillPersonMap.put(className, skillLocalNum + skillOtherNum);
        }

        // 对数据进行 对比
        LinkedHashMap<String, List<String>> skillTempMap = new LinkedHashMap<>();
        List<String> currentGroupList = new ArrayList<>();
        int currentSum = 0;

        // 遍历 baseList
        for (SignBase base : baseList) {
            Iterator<Map.Entry<String, Integer>> iterator = skillPersonMap.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, Integer> entry = iterator.next();
                String groupName = entry.getKey();
                int groupPersonCount = entry.getValue();
                // 检查当前累加的总人数是否小于等于 roomNum
                if (currentSum + groupPersonCount <= base.getPersonNum()) {
                    currentSum += groupPersonCount;
                    currentGroupList.add(groupName);
                    // 从 skillPersonMap 中移除已经分配的技术组
                    iterator.remove();
                }
            }

            // 如果当前组已经分配完成
            if (currentSum > 0) {
                skillTempMap.put(base.getBaseRoom(), new ArrayList<>(currentGroupList));
                currentSum = 0;
                currentGroupList.clear();
            }
        }

        // 处理剩余的技术组
        if (!skillPersonMap.isEmpty()) {
            throw new CommonException(CommonConstants.ERROR, "无法分配所有技术组，剩余技术组人数超过可用评标室容量");
        }

        // 对数据 进行处理
        for (Map.Entry<String, List<String>> entry : skillTempMap.entrySet()) {
            String key = entry.getKey();
            List<String> stringList = entry.getValue();
            for (String str : stringList) {
                for (WzBaseVo vo : list) {
                    if (!vo.getSkillClass().equals(str)) {
                        continue;
                    }

                    if (vo.getSkillClass().equals(str)) {
                        vo.setSkillBaseRoom(baseName + key);
                    }
                }
            }
        }

        // 获取 评标基地 信息 商务 北   技术 南
        List<SignBase> bossBaseList = signBaseMapper.selectBaseListByFlag("北", disclose.getId());
        // 对数据进行处理， 对其数据进行分配评标室
        // 根据 技术 组 的分组 将数据 封装到 map 中
        Map<String, List<WzBaseVo>> bossClassMap = list.stream()
                .collect(Collectors.groupingBy(WzBaseVo::getBossClass));

        // 将 技术组 组名以及 总认识 取出
        LinkedHashMap<String, Integer> bossPersonMap = new LinkedHashMap<>();
        for (int i = 0; i < bossClassMap.size(); i++) {
            String className = "商务" + convertToChinese(i + 1) + "组";
            List<WzBaseVo> voList = bossClassMap.get(className);
            if (voList.isEmpty()) {
                continue;
            }
            // 物资 处理 人数
            // 本地
            Integer bossLoacalNum = voList.get(0).getBossLoacalNum();
            // 异地
            Integer bossOtherNum = voList.get(0).getBossOtherNum();
            if (bossOtherNum == null) {
                bossOtherNum = 0;
            }
            bossPersonMap.put(className, bossLoacalNum + bossOtherNum);
        }

        // 对数据进行 对比
        LinkedHashMap<String, List<String>> bossTempMap = new LinkedHashMap<>();
        List<String> bossGroupList = new ArrayList<>();
        int bossSum = 0;

        for (SignBase base : bossBaseList) {
            Iterator<Map.Entry<String, Integer>> iterator = bossPersonMap.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, Integer> entry = iterator.next();
                String groupName = entry.getKey();
                int groupPersonCount = entry.getValue();
                // 检查当前累加的总人数是否小于等于 roomNum
                if (bossSum + groupPersonCount <= base.getPersonNum()) {
                    bossSum += groupPersonCount;
                    bossGroupList.add(groupName);
                    iterator.remove();
                }
            }

            // 如果当前组已经分配完成
            if (bossSum > 0) {
                bossTempMap.put(base.getBaseRoom(), new ArrayList<>(bossGroupList));
                bossSum = 0;
                bossGroupList.clear();
            }
        }

        // 处理剩余的商务组
        if (!bossPersonMap.isEmpty()) {
            throw new CommonException(CommonConstants.ERROR, "无法分配所有商务组，剩余商务组人数超过可用评标室容量");
        }

        // 对数据 进行处理
        for (Map.Entry<String, List<String>> entry : bossTempMap.entrySet()) {
            String key = entry.getKey();
            List<String> stringList = entry.getValue();
            for (String str : stringList) {
                for (WzBaseVo vo : list) {
                    if (!vo.getBossClass().equals(str)) {
                        continue;
                    }

                    if (vo.getBossClass().equals(str)) {
                        vo.setBossBaseRoom(baseName + key);
                    }
                }
            }
        }


        return list;
    }

    // 传入 数字 返回 其中文样式
    public static String convertToChinese(int number) {
        if (number < 1 || number > 99) {
            throw new IllegalArgumentException("支持的范围是 1 到 99");
        }

        String[] chineseDigits = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};

        int tens = number / 10;
        int units = number % 10;

        StringBuilder result = new StringBuilder();

        if (tens > 0) {
            result.append(chineseDigits[tens]);
            result.append("十");
        }

        if (units > 0 || tens == 0) { // 处理个位是0的情况
            result.append(chineseDigits[units]);
        }

        // 如果只有十位数而个位数是0，不要显示个位的零
        return result.toString().replaceAll("^一十", "十"); // 将 "一十" 转换为 "十"
    }

    public static String extractGroupName(String input) {
        // 找到第一个数字字符的位置
        int index = -1;
        for (int i = 0; i < input.length(); i++) {
            if (Character.isDigit(input.charAt(i))) {
                index = i;
                break;
            }
        }
        // 如果没有找到数字字符，返回原字符串
        if (index == -1) {
            return input;
        }

        // 截取数字字符之前的部分
        return input.substring(0, index);
    }

    public static Integer extractNumber(String input) {
        StringBuilder numberPart = new StringBuilder();

        // 遍历字符串，提取数字部分，直到遇到括号或其他非数字字符
        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            if (Character.isDigit(c)) {
                numberPart.append(c);
            } else if (c == '（' || c == '(') {
                // 遇到左括号时停止提取
                break;
            }
        }

        return Integer.valueOf(numberPart.toString());
    }
}
